/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package javalee.util;

import com.mysql.jdbc.Connection;
import com.sun.rowset.CachedRowSetImpl;
import java.sql.DriverManager;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.sql.ResultSet;
import java.sql.SQLException;
import javax.sql.rowset.CachedRowSet;
import javax.swing.JOptionPane;

/**
 *
 * @author ricardo
 */
public class Calculos {
   
    /**
     * Construtor da classe. Faz as configurações basicas para a conexão com o banco de dados.
     */
    public Calculos()
    {
        conexao = new ADOLee();
    }
    /**
     * Calcula a necessidade de producão para o atendimento da previsão de demanda revista.
     * @param demandaRevista Resultset que contém a demanda revista.
     * @return Produção recalculada/efetiva.
     */
    public ResultSet producaoRecalc(CachedRowSet demandaRevista)
    {
        String sqlBase = "SELECT DISTINCT temp.id_produto, COALESCE(demanda_estimada,0) as demanda_estimanda, "
                + "COALESCE(carteira,0) as carteira FROM (SELECT id_produto FROM itens_venda INNER JOIN venda ON "
                + "(id_venda = id and `data_entrega` BETWEEN ('2012-01-01') AND ('2012-01-31')) GROUP BY id_produto "
                + "UNION SELECT id_produto FROM itens_venda INNER JOIN venda ON "
                + "(id_venda = id and `data` BETWEEN ('2011-01-01') AND ('2011-01-31')) GROUP BY id_produto) AS temp "
                + "LEFT JOIN (SELECT id_produto, SUM(COALESCE(qtdade, 0)) as carteira FROM itens_venda "
                + "INNER JOIN venda ON  (id_venda = id and `data_entrega` BETWEEN ('2012-01-01') AND ('2012-01-31')) "
                + "GROUP BY id_produto) AS cart ON (temp.id_produto = cart.id_produto) "
                + "LEFT JOIN (SELECT id_produto, SUM(COALESCE(qtdade, 0)) as demanda_estimada FROM itens_venda "
                + "INNER JOIN venda ON  (id_venda = id and `data` BETWEEN ('2011-01-01') AND ('2011-01-31')) "
                + "GROUP BY id_produto) AS demand ON (temp.id_produto = demand.id_produto)";
        int[] diasUteis = {5,5,5,5,2};
        try
        {
//            conexao.conectar();
            ResultSet rsBase = conexao.selecionar(sqlBase);  //Cria um novo resultset com os id, demanda estimada total e pedidos em carteira total
           
            CachedRowSet rsDemandRev = new CachedRowSetImpl();
            demandaRevista.beforeFirst();
            rsDemandRev.populate(demandaRevista);//Faz uma cópia do objeto passado por refencia para alterar
            rsDemandRev.first();
            do
            {
                rsBase.absolute(buscaID(rsBase, rsDemandRev.getInt("id_produto"))); //Localiza a linha que possui a mesma id do rs principal
                int totalDemandaRevista = maior(rsBase.getInt("demanda_estimanda"), rsBase.getInt("carteira"));//Pega o maior valor entre a demanda estimada e os pedidos em carteira
                int[] producaoPlanejada = producaoPlanejada(totalDemandaRevista, diasUteis); //Calcula a producao planejada
                int[] estoqueProjetado = estoqueProjetado(getValores(rsDemandRev, rsDemandRev.getRow()), //Calcula o estoque projetado
                        producaoPlanejada, rsDemandRev.getInt("qtdade"));
                int[] prodRecalc = producaoRecalculada(rsDemandRev.getInt("nivel_critico"), estoqueProjetado, producaoPlanejada);//Faz os ajustes necessários - recalcula producao
                gravaDados(rsDemandRev, prodRecalc);//grava os dados no resultset local - copia do rs da demanda recalculada
            }while(rsDemandRev.next());
            rsDemandRev.beforeFirst();
            return rsDemandRev;//retorna o rs local
        }
        catch (Exception e)
        {
            JOptionPane.showMessageDialog(null, "Calculo da produção recalculada. " + e.getMessage());            
        }
        return null;
    }
    
    public ResultSet buscaComposicao(ResultSet producaoRecalculada)
    {
        try
        {
            CachedRowSet rsFinal = new CachedRowSetImpl();
            CachedRowSet rsTemp = new CachedRowSetImpl();
            producaoRecalculada.last();
            rsFinal.populate(producaoRecalculada);//Pega as informacoes de layout dos dados
            producaoRecalculada.beforeFirst();            
            rsTemp.populate(procuraComposicao(producaoRecalculada));
            int sair = 0;
            while(sair == 0)
            {
                while(rsTemp.next())
                {
                    rsFinal.moveToInsertRow();
                    rsFinal.updateInt("id_produto", rsTemp.getInt("id_produto")); 
                    rsFinal.updateInt("qtdade", rsTemp.getInt("qtdade"));
                    rsFinal.updateString("origem", rsTemp.getString("origem"));
                    rsFinal.updateInt("nivel_critico", rsTemp.getInt("nivel_critico"));
                    rsFinal.updateInt("qnt1", rsTemp.getInt("qnt1"));
                    rsFinal.updateInt("qnt2", rsTemp.getInt("qnt2"));
                    rsFinal.updateInt("qnt3", rsTemp.getInt("qnt3"));
                    rsFinal.updateInt("qnt4", rsTemp.getInt("qnt4"));
                    rsFinal.updateInt("qnt5", rsTemp.getInt("qnt5"));
                    rsFinal.insertRow();
                    rsFinal.moveToCurrentRow();
                } 
                CachedRowSet limpo = new CachedRowSetImpl();
                limpo.populate(procuraComposicao(rsTemp));
                rsTemp = new CachedRowSetImpl();  
                rsTemp.populate(limpo);
                rsTemp.last();
                if(rsTemp.getRow() == 0)
                    sair = 1;
                rsTemp.beforeFirst();
            }
            consolidaComposicao(rsFinal);
            rsFinal.beforeFirst();
            return rsFinal;
        }
        catch (Exception e)
        { 
            JOptionPane.showMessageDialog(null, e.getMessage());
        }
        return null;
    }
    
    
    /**
     * 
     * @param producaoRecalculada
     * @return 
     */
    public ResultSet procuraComposicao(ResultSet producaoRecalculada)
    {
        /*
         * Idéia: No rsComposicao terá informações dos produtos de origem F, I e M.
         * Os produtos M já são as saídas de pedido de compra (que devem ser separados posteriormente.
         * Os produtos F ou I terão as informações de necessidade de produção por semana.
         */
        try
        {
            CachedRowSet rsComposicao = new CachedRowSetImpl();
            producaoRecalculada.last();//Posiciona na ultima linha o rs
            int tamanho = producaoRecalculada.getRow(); // aproveita pra saber o tamanho do rs
            
            //Popula o rs somente para pegar as informações de colunas
            //id_produto, qtdade, origem, nivel_critico, qnt1, qnt2, qnt3, qnt4 e qnt5
            rsComposicao.populate(producaoRecalculada);
            producaoRecalculada.beforeFirst(); //Volta o rs para o começo
            while(producaoRecalculada.next())
            {
                String sql = "SELECT id_prod_composto, qtdade FROM itens_estrut WHERE id_produto = " + producaoRecalculada.getInt("id_produto");
                ResultSet rsTemp = conexao.selecionar(sql);
                if(rsTemp != null)
                {
                    while(rsTemp.next())
                    {
                        //coleta informaçoes adicionais do produto para inserir na base
                        ResultSet rsInfoProduto = conexao.selecionar("SELECT qtdade, origem, nivel_critico FROM produto WHERE id =  " + rsTemp.getInt("id_prod_composto"));
                        rsInfoProduto.first(); //Sempre vai retornar uma unica linha
                        
                        int[] producao = getValores(producaoRecalculada, producaoRecalculada.getRow()); //pega as informacoes de producao por semana
                        //calula a demanda revista
                        for(int a=1; a<5;a++)
                        {
                            producao[a-1] = producao[a] * rsTemp.getInt("qtdade"); //multiplica pela quantidade necessaria para cada produto
                        }
                        producao[4] = producao[4] *  rsTemp.getInt("qtdade");
                        
                        int somaDemanda = somaVetor(producao, 0, 5); //Faz a soma da demanda para calcular a producao planejada
                        int[] diasUteis = {5,5,5,5,2};//cria o vetor de dias uteis do mes
                        int[] producaoPlanejada = producaoPlanejada(somaDemanda, diasUteis);//calcula a producao planejada
                        int[] estoqueProjetado = estoqueProjetado(producao, producaoPlanejada, rsInfoProduto.getInt("qtdade")); //Calcula o estoque projetado
                        int[] producRecalc = producaoRecalculada(rsInfoProduto.getInt("nivel_critico"), estoqueProjetado, producaoPlanejada);//Recalcula a producao necessaria
                   
                        //Insere uma nova linha no rs
                        rsComposicao.moveToInsertRow();
                        rsComposicao.updateInt("id_produto", rsTemp.getInt("id_prod_composto") );
                        rsComposicao.updateInt("qtdade", rsInfoProduto.getInt("qtdade"));
                        rsComposicao.updateString("origem", rsInfoProduto.getString("origem"));
                        rsComposicao.updateInt("nivel_critico", rsInfoProduto.getInt("nivel_critico"));
                        rsComposicao.updateInt("qnt1", 0);
                        rsComposicao.updateInt("qnt2", 0);
                        rsComposicao.updateInt("qnt3", 0);
                        rsComposicao.updateInt("qnt4", 0);
                        rsComposicao.updateInt("qnt5", 0);
                        rsComposicao.insertRow();//insere a linha
                        rsComposicao.moveToCurrentRow(); //move o cursor para a linha que estava anteriormente
                        rsComposicao.next();//move o cursor para a linha atual                                
                        gravaDados(rsComposicao, producRecalc);//grava os dados no rsComposicao     
                    }
                }
            }
            consolidaComposicao(rsComposicao);
            rsComposicao.beforeFirst();
            return rsComposicao;
        }
        catch(Exception e)
        {
            JOptionPane.showMessageDialog(null, e.getMessage());
        }
        return null;
    }
    
    private void consolidaComposicao(CachedRowSet rsComposicao) throws Exception
    {
        rsComposicao.last();
        if(rsComposicao.getRow() != 0)
        {
            rsComposicao.beforeFirst();
            int absolute = 1;
            while(rsComposicao.next())
            {
                int idAtual = rsComposicao.getInt("id_produto");
                int[] valores  = getValores(rsComposicao, absolute);
                while(rsComposicao.next())
                {
                    if(rsComposicao.getInt("id_produto") == idAtual)
                    {
                        int[] valorLinha = getValores(rsComposicao, rsComposicao.getRow());
                        for(int a =0; a<5; a++)
                        {
                            valores[a] += valorLinha[a];
                        }
                       rsComposicao.deleteRow();
                    }
                }
                rsComposicao.absolute(absolute);
                gravaDados(rsComposicao, valores);
                absolute++;
            }
        }
    }
    
    /**
     * Calculo principal do módulo de produção
     * @param nivelCritico Valor obtido da tabela de produtos
     * @param estoqueProjetado Vetor obtido por outro método local
     * @param producaoPlanejada Vetor obtido por outro método local
     * @return Vetor com a produção recalculada/final 
     */
    private int[] producaoRecalculada(int nivelCritico, int[] estoqueProjetado, int[] producaoPlanejada)
    {
        int[] prodRec = { 0,0,0,0,0};
        for(int a =0; a < 5;a++)
        {
            if (a==0)
            {
                    prodRec[a] = (nivelCritico - estoqueProjetado[a+1]) + producaoPlanejada[a] ;
            }
            else
            {
                    prodRec[a] = (nivelCritico - estoqueProjetado[a+1]) + producaoPlanejada[a] + 
                        (somaVetor(producaoPlanejada, 0, a) - somaVetor(prodRec, 0, a)) ;
            }
        }
        return prodRec;
    }
    
    
    /**
     * Faz o calculo do estoque projetado
     * @param demandaRevista Vetor contendo a demanda revista
     * @param producaoPlanejada Vetor com a producao recalculada
     * @param estoque Quantidade atual de estoque do produto
     * @return Vetor com o estoque projetado para o produto
     */
    private int[] estoqueProjetado(int[] demandaRevista, int[] producaoPlanejada, int estoque)
    {
        int[] estProj = {estoque,0,0,0,0,0};
        for(int a =1; a<6; a++)
        {
            estProj[a] = estProj[a-1] + producaoPlanejada[a-1] - demandaRevista[a-1]; 
        }
        return estProj;
    }
    
    /**
     * Calcula a produção planejada
     * @param totalDemanda Total da demanda revista para o produto.
     * @param diasUteis Vetor com os dias úteis para 5 semanas. No caso de meses com 4, a ultima semana vei "zerada".
     * @return Vetor de inteiros com a produção planejada para 5 semanas.
     */
    private int[] producaoPlanejada(int totalDemanda, int[] diasUteis)
    {
        int[] producao = {0,0,0,0,0};
        int totalDiasUteis = somaVetor(diasUteis, 0, 5);
        if(totalDemanda > 0)
        {
            for(int a = 0; a < 4; a++)
            {
                producao[a] = (diasUteis[a] * totalDemanda) / totalDiasUteis;
            }
            producao[4] = totalDemanda - somaVetor(producao, 0, 5);
        }
        return producao;
    }
    
    /**
     * Módulo de cálculo da demanda revista. Necessário para execução da produção recalculada
     * @return ResultSet com as informações da demanda revista.
     */
    public ResultSet demandaRevista()
    {
        String sqlPrevisao = "SELECT id_produto, SUM(qtdade) as quantidade, FLOOR(SUM(qtdade)/22*5) as qnt1, " +
	"FLOOR(SUM(qtdade)/22*5) as qnt2, " +
	"FLOOR(SUM(qtdade)/22*5) as qnt3, " + 
	"FLOOR(SUM(qtdade)/22*5) as qnt4, " +
	"(SUM(qtdade) - (FLOOR(SUM(qtdade)/22*5) + FLOOR(SUM(qtdade)/22*5) + " +
                        "FLOOR(SUM(qtdade)/22*5)+ FLOOR(SUM(qtdade)/22*5))) as qnt5 " + 
                    "FROM itens_venda INNER JOIN venda ON (id_venda = id and `data` BETWEEN ('2011-01-01') AND ('2011-01-31')) " +
                    "GROUP BY id_produto;";
        
        String sqlCarteira = "SELECT ids.id_produto, qnt1, qnt2, qnt3, qnt4, qnt5 FROM " +
	"(SELECT id_produto FROM itens_venda INNER JOIN venda " +
  	 "ON (id_venda = id and `data_entrega` BETWEEN ('2012-01-01') AND ('2012-01-31')) " +
 	"GROUP BY id_produto) AS ids " +
                    "LEFT JOIN (SELECT id_produto, SUM(COALESCE(qtdade,0)) as qnt1 FROM itens_venda INNER JOIN venda " +
  	"ON (id_venda = id and `data_entrega` BETWEEN ('2012-01-02') AND ('2012-01-06')) GROUP BY id_produto) AS ids1 " +
                    "ON (ids1.id_produto = ids.id_produto) " +
                    "LEFT JOIN (SELECT id_produto, SUM(COALESCE(qtdade,0)) as qnt2 FROM itens_venda INNER JOIN venda " + 
  	"ON (id_venda = id and `data_entrega` BETWEEN ('2012-01-09') AND ('2012-01-13')) GROUP BY id_produto) AS ids2 " +
                    "ON (ids2.id_produto = ids.id_produto) " +
                    "LEFT JOIN (SELECT id_produto, SUM(COALESCE(qtdade,0)) as qnt3 FROM itens_venda INNER JOIN venda " +
  	"ON (id_venda = id AND `data_entrega` BETWEEN ('2012-01-16') AND ('2012-01-20')) GROUP BY id_produto) AS ids3 " +
                    "ON (ids3.id_produto = ids.id_produto) " + 
                    "LEFT JOIN (SELECT id_produto, SUM(COALESCE(qtdade,0)) as qnt4 FROM itens_venda INNER JOIN venda " +
  	"ON (id_venda = id AND `data_entrega` BETWEEN ('2012-01-23') AND ('2012-01-27')) GROUP BY id_produto) AS ids4 " +
                    "ON (ids4.id_produto = ids.id_produto) " +
                    "LEFT JOIN (SELECT id_produto, SUM(COALESCE(qtdade,0)) as qnt5 FROM itens_venda INNER JOIN venda " +
  	"ON (id_venda = id AND `data_entrega` BETWEEN ('2012-01-30') AND ('2012-01-31')) GROUP BY id_produto) AS ids5 " +
                    "ON (ids5.id_produto = ids.id_produto);";
        
        String sqlTratados = "SELECT DISTINCT id_produto, qtdade, origem, nivel_critico, 0 as qnt1, 0 as qnt2, 0 as qnt3, 0 as qnt4, " + 
	"0 as qnt5 FROM (SELECT id_produto FROM itens_venda INNER JOIN venda "
                + "ON (id_venda = id and `data_entrega` BETWEEN ('2012-01-01') AND ('2012-01-31')) GROUP BY id_produto "
                + "UNION SELECT id_produto FROM itens_venda INNER JOIN venda "
                + "ON (id_venda = id and `data` BETWEEN ('2011-01-01') AND ('2011-01-31')) GROUP BY id_produto) AS temp "
                + "LEFT JOIN produto ON (id_produto = id) ORDER BY id_produto;";
        try{
            //Estabelece a conexão com a base de dados
            conexao.conectar();
            
            ResultSet rsPrevisao = conexao.selecionar(sqlPrevisao); //Carrega o rs da previsão de vendas
            ResultSet rsCarteira = conexao.selecionar(sqlCarteira);//Carrega o rs da carteira de vendas (ja vendido)
            CachedRowSet rsDemandaRevista = new CachedRowSetImpl(); 
            
            /*
             * Popula a demanda revista com todos os ids distintos de produtos existentes entre a previsao e a carteira,
             *uma vez que podem existir produtos previstos e nao vendidos, assim como produtos vendidos nao previstos.
             * Isso cria um guia de ids para os cálculos posteriores. Todos os demais campos são "zerados" para serem 
             * alterados depois dos cálculos.
            */
            rsDemandaRevista.populate(conexao.selecionar(sqlTratados));//Popula da demanda revista 
            int[] diasUteis = {5,5,5,5,2}; //Cria o vetor com a quantidade de dias úteis
            while(rsDemandaRevista.next())//Percorre todos os ids distintos encontrados
            {
                int id = rsDemandaRevista.getInt("id_produto");//Pega o id atual
                int[] prev = getValores(rsPrevisao, buscaID(rsPrevisao, id));//Encotra em qual linha do rsPrevisão está o id e carrega no vetor
                int[] cart = getValores(rsCarteira, buscaID(rsCarteira, id));//Encotra em qual linha do rsCarteira está o id e carrega no vetor
                int[] demanda = trataLinha(prev, cart, diasUteis);//Calcula a demanda revista e popula o vetor
                gravaDados(rsDemandaRevista, demanda);//Altera a linha do CachedRowSet com as informações calculadas do vetor
            }
            rsDemandaRevista.beforeFirst();
            return rsDemandaRevista; //Retorna o CachedRowSet com todas as linhas calculadas  
            
        } catch (Exception ex) {
            JOptionPane.showMessageDialog(null, "Calculo da demanda prevista. " + ex.getMessage());
        }
        
        return null;
    }
    
    /*
     * Grava os dados calculados do vetor em um cachedrowset passado por referencia ao método.
     */
    private void gravaDados(CachedRowSet cache, int[] linha)
    {
        try {
            for(int a = 0; a < 5; a++)
            {
                String coluna = "qnt" + (a+1);
                cache.updateInt(coluna, linha[a]);
            }
            cache.updateRow();
        } catch (SQLException ex) {
            JOptionPane.showMessageDialog(null, "gravaDados. " + ex.getMessage());
        }
    }
    
    /**
     * Transforma uma linha do resultset em vetor para ser usado em calculos.
     */
    private int[] getValores(ResultSet rs, int absolute) throws Exception
    {
        int[] a;
        if(absolute > 0)
        {
            try
            {
                rs.absolute(absolute);
                a = new int[] {rs.getInt("qnt1"), rs.getInt("qnt2"), rs.getInt("qnt3"), rs.getInt("qnt4"), rs.getInt("qnt5")};
            }
            catch (Exception e)
            {
                throw new Exception("getValores. " + e.getMessage());
            }
        }
        else
        {
            a = new int[] {0,0,0,0,0};
        }
        return a;
    }
    
    /**
     * === MODULO PRINCIPAL - DEMANDA REVISTA ===
     * Efetua de fato o calculo das linhas ja transformadas em vetores. Daqui sai o resultado
     * final da demanda revista.
     */
    private int[] trataLinha(int[] previsao, int[] carteira, int[] diasUteis)
    {
        int acimaPrevisao = 0;
        int diluicao = 0;
        int[] resultado = new int[5];
  
        //tratamento das colunas
        for(int a = 0; a < 5; a++)
        {            
              if(a<4)
              {
                  resultado[a] = maior(previsao[a] - diluicao, carteira[a]);
                  acimaPrevisao += resultado[a] - previsao[a];
                  if(a<3)
                        diluicao = acimaPrevisao * diasUteis[a+1] / somaVetor(diasUteis, a+1, 5);
              }
              else
              {
                  resultado[a] = maior(previsao[a] - acimaPrevisao, carteira[a]);
              }
        }
        return resultado;
    }
    
    /**
     * Usado para calcular a soma dos dias uteis restantes do mês - especificamente compõe o 
     * calculo da "diluição da previsão"
     * @param vetor Vetor de inteiros a ser somado
     * @param inicio Posicao de inicio de soma
     * @return  Somatório.
     */
    private int somaVetor(int[] vetor, int inicio, int fim)
    {
        int a = 0;
        for(int b = inicio;b < fim; b++ )
        {
            a += vetor[b];
        }
        return a;
    }
    
    /**
     * Retorna o maior dentre dois valores
     */
    private int maior(int a, int b)
    {
        if(a > b)
            return a;
        return b;
    }
    
    /**
     * Retorna o numero da linha de um resultset onde localiza-se o id informado
     */
    private int buscaID(ResultSet rs, int id)
    {
        try
        {
            rs.first();
            do             
            {
                 if (rs.getInt("id_produto") == id)
                     return (rs.getRow());
            }while(rs.next());
        }
       catch (Exception ex)
       {
           JOptionPane.showMessageDialog(null, "buscaID. " + ex.getMessage());
       }
        return 0;
    }
    
    
    
    
//    /*
//     * ===================================================================================
//     * ===================================================================================
//     * Daqui pra baixo falta arrumar.......................
//     */
//    public ResultSet calculaDemanda()
//    {
//        String consultaPrincipal = "SELECT  id_produto,  MAX(quantidade) as quant FROM " +
//                                                        "(SELECT id_produto, SUM(qtdade) as quantidade " + 
//                                                            "FROM itens_venda INNER JOIN "+
//                                                                "(SELECT id FROM venda WHERE "+
//                                                                    "`data` BETWEEN ('2011-01-01') AND ('2011-01-31')) AS temp "+ 
//                                                            "ON (id_venda = id) GROUP BY id_produto "+
//                                                            "UNION SELECT id_produto, SUM(qtdade) as quantidade "+
//                                                            "FROM itens_venda INNER JOIN " +
//                                                                "(SELECT id FROM venda WHERE "+
//                                                                    "`data_entrega` BETWEEN ('2012-01-01') AND ('2012-01-31')) AS temp "+
//                                                            "ON (id_venda = id) GROUP BY id_produto) as t1 "+
//                                                  "GROUP BY id_produto;";
//        try {
//            conexao.conectar();
//            CachedRowSet rsPrincipal = new CachedRowSetImpl();
//            rsPrincipal.populate(conexao.selecionar(consultaPrincipal));
////            ResultSet rsPrincipal = conexao.selecionar(consultaPrincipal);
//            while(rsPrincipal.next())
//            {
//                ResultSet rsTemp = this.procuraComposicao(rsPrincipal.getInt("id_produto"), 
//                        rsPrincipal.getInt("quant"));
//                if(rsTemp != null)
//                {
//                    rsTemp.first();
//                    do
//                    {
//                        rsPrincipal.moveToInsertRow();
//                        rsPrincipal.updateInt("id_produto", rsTemp.getInt("id_prod_composto"));
//                        rsPrincipal.updateInt("quant", rsTemp.getInt("qtdade"));
//                        rsPrincipal.insertRow();
//                        rsPrincipal.moveToCurrentRow();
//                    }while(rsTemp.next());
//                }
//            }
//            return rsPrincipal;
//        } catch (Exception ex) {
//            JOptionPane.showMessageDialog(null, "rsPrincipal " + ex.getMessage());
//        }
//        return null; 
//    }
       

    /*
     * ===================================================================================
     * ===================================================================================
     */
    
    /**
     * Implementação da classe de conexão não public. (Não sei usar o rolo do javalee.dao.....kkkkkk)
     */
    class ADOLee 
    {
        public void conectar() throws Exception
        {   
            try 
            {
                Class.forName("com.mysql.jdbc.Driver").newInstance();
                conn = (Connection) DriverManager.getConnection("jdbc:mysql://localhost/javalee?user=javalee&password=javalee");
            } catch (SQLException e) {
                Logger.getLogger(ADOLee.class.getName()).log(Level.SEVERE, null, e);
                throw new Exception("Erro no comando SQL: " + e.getMessage());
            }
        }

        public void fechar() throws Exception
        {
            try
            {
                conn.close();
            }
            catch (SQLException e)
            {
                Logger.getLogger(ADOLee.class.getName()).log(Level.SEVERE, null, e);
                throw new Exception ("Erro no comando SQL: "+ e.getMessage());
            }
        }

        public ResultSet selecionar(String consulta) throws Exception
        {
            try
            {
                java.sql.Statement stm = conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_READ_ONLY);
                return(stm.executeQuery(consulta));
            }
            catch (SQLException e)
            {
                  Logger.getLogger(ADOLee.class.getName()).log(Level.SEVERE, null, e);
                  throw new Exception("Erro no comando SQL: " + e.getMessage());
            }
        }
        private Connection conn;
    }
    
      /**
     * Métodos e variaveis private
     */
    private ADOLee conexao;   
//    private ResultSet resultados;    
}
